home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update19.zoo / lib / diffs
Encoding:
Text File  |  1992-03-28  |  11.4 KB  |  551 lines
  1. *** 1.69    1992/03/22 21:57:30
  2. --- Changelo    1992/03/28 06:36:49
  3. ***************
  4. *** 2911,2913 ****
  5. --- 2911,2931 ----
  6.       merge diff for atof
  7.   
  8.   ---------------------------- Patchlevel 78 ---------------------------
  9. + signal.c, console.c: alexander lehmann
  10. +   fix for a bug where console i/o would get stuck when a interrupt
  11. +   was caught and it occured when the input buffer was not empty.
  12. + 
  13. + 
  14. + fread.c, fwrite.c: alexander lehmann
  15. +   I rewrote fread and fwrite to do CR/LF conversion when in text mode.
  16. +   Additionally I fixed a small bug in eof detection.
  17. + 
  18. +   ( this pertains to the example when you are fread'ing say 20 bytes
  19. +     from a file that contains 18 bytes: in the old coding
  20. +     you would first succeeed with a count of 18, and on subsequent
  21. +     freads you would get eof. In this coding, you get a count of 18
  22. +     and also eof flag:
  23. +     Well this was not really a bug, just when eof shows up. My ansiC
  24. +     doc is mum on this point) -- ++jrb
  25. + 
  26. + ---------------------------- Patchlevel 79 ---------------------------
  27. *** 1.54    1992/03/22 21:57:30
  28. --- PatchLev.h    1992/03/28 06:37:02
  29. ***************
  30. *** 1,5 ****
  31.   
  32. ! #define    PatchLevel "78"
  33.   
  34.   /*
  35.    *
  36. --- 1,5 ----
  37.   
  38. ! #define    PatchLevel "79"
  39.   
  40.   /*
  41.    *
  42. *** 1.9    1991/09/24 16:44:02
  43. --- console.c    1992/03/24 18:54:00
  44. ***************
  45. *** 36,43 ****
  46.   } k_buf;
  47.   
  48.   k_buf in_buf[NUMDEV];
  49. - #define IN_BUF(dev) (&in_buf[(dev) > 2 ? _console_dev : (dev)])
  50.   
  51.   /*
  52.    * what handle means:: 0-2: BIOS handle, 3: stdout, 4: stderr
  53.    */
  54. --- 36,46 ----
  55.   } k_buf;
  56.   
  57.   k_buf in_buf[NUMDEV];
  58.   
  59. + #define in_dev(dev) ((dev)>2 ? _console_dev : (dev))
  60. + 
  61. + #define IN_BUF(dev) (&in_buf[in_dev(dev)])
  62. + 
  63.   /*
  64.    * what handle means:: 0-2: BIOS handle, 3: stdout, 4: stderr
  65.    */
  66. ***************
  67. *** 44,49 ****
  68. --- 47,53 ----
  69.   static short LOOKUP __PROTO((short handle));
  70.   static long raw_in __PROTO((int dev));
  71.   static long raw_instat __PROTO((int dev));
  72. + void flush_key_buff __PROTO((int dev));
  73.   #if 0
  74.   static void raw_out __PROTO((int dev, int c));
  75.   #endif
  76. ***************
  77. *** 81,92 ****
  78.   raw_in(dev)
  79.   int dev;
  80.   {
  81. !     if (dev < 3)
  82. !         return Bconin(dev);
  83. !     else if (dev == 3)
  84. !         return Crawcin();
  85. !     else
  86. !         return Cauxin();
  87.   }
  88.   
  89.   #if 0
  90. --- 85,91 ----
  91.   raw_in(dev)
  92.   int dev;
  93.   {
  94. !     return Bconin(in_dev(dev));
  95.   }
  96.   
  97.   #if 0
  98. ***************
  99. *** 107,118 ****
  100.   raw_instat(dev)
  101.   int dev;
  102.   {
  103. !     if (dev < 3)
  104. !         return Bconstat(dev);
  105. !     else if (dev == 3)
  106. !         return Cconis();
  107. !     else
  108. !         return Cauxis();
  109.   }
  110.   
  111.   /*
  112. --- 106,112 ----
  113.   raw_instat(dev)
  114.   int dev;
  115.   {
  116. !     return Bconstat(in_dev(dev));
  117.   }
  118.   
  119.   /*
  120. ***************
  121. *** 165,208 ****
  122.   int handle;
  123.   int n;
  124.   {
  125. -     long c;
  126. -     short i, j, waiting = 0;
  127.       char ch;
  128. -     k_buf *p;
  129.       short dev;
  130.   
  131.       dev = LOOKUP(handle);
  132. -     p = IN_BUF(dev);
  133.   
  134. !     while (__check_signals && (raw_instat(dev) || waiting)) {
  135. !         c = raw_in(dev);
  136. !         if (!(__ttymode & RAW)) {
  137. !             ch = c & 0xff;
  138. !             if (ch == ('S'-'@')) {
  139. !                 waiting = 1;
  140. !             }
  141. !             else if (ch == ('Q'-'@')) {
  142. !                 waiting = 0;
  143. !             }
  144. !             else if (ch == __tchars[TC_INTRC]) {
  145. !                 p->head = p->tail;
  146. !                 raise(SIGINT);
  147. !             }
  148. !             else if (ch == __tchars[TC_QUITC]) {
  149. !                 p->head = p->tail;
  150. !                 raise(SIGQUIT);
  151. !             }
  152. !             else if (!waiting) {
  153. !                 i = p->head;
  154. !                 j = i + 1;
  155. !                 if (j >= KBUFSIZ) j = 0;
  156. !                 if (j != p->tail) {
  157. !                     p->buffer[i] = c;
  158. !                     p->head = j;
  159. !                 }
  160. !             }
  161. !         }
  162. !     }
  163.   /*    raw_out(dev, n); */
  164.       ch = n;
  165.       (void)Fwrite(handle, 1L, &ch);
  166. --- 159,171 ----
  167.   int handle;
  168.   int n;
  169.   {
  170.       char ch;
  171.       short dev;
  172.   
  173.       dev = LOOKUP(handle);
  174.   
  175. !     if (__check_signals)
  176. !         flush_key_buff(dev);
  177.   /*    raw_out(dev, n); */
  178.       ch = n;
  179.       (void)Fwrite(handle, 1L, &ch);
  180. ***************
  181. *** 255,257 ****
  182. --- 218,221 ----
  183.       }
  184.       }
  185.   }
  186. + 
  187. *** 1.11    1992/03/22 21:57:30
  188. --- fread.c    1992/03/24 18:54:21
  189. ***************
  190. *** 1,4 ****
  191. ! /* nothing like the origonal from
  192.    * from Dale Schumacher's dLibs
  193.    */
  194.   
  195. --- 1,4 ----
  196. ! /* nothing like the original from
  197.    * from Dale Schumacher's dLibs
  198.    */
  199.   
  200. ***************
  201. *** 10,17 ****
  202.   #include <string.h>
  203.   #include "lib.h"
  204.   
  205. ! size_t  fread(data, size, count, fp)
  206. !     register void *data;
  207.       size_t size;
  208.       size_t count;
  209.       register FILE *fp;
  210. --- 10,17 ----
  211.   #include <string.h>
  212.   #include "lib.h"
  213.   
  214. ! size_t    fread(_data, size, count, fp)
  215. !     void *_data;
  216.       size_t size;
  217.       size_t count;
  218.       register FILE *fp;
  219. ***************
  220. *** 19,24 ****
  221. --- 19,26 ----
  222.       register size_t n;
  223.       register long l, cnt;
  224.       register unsigned int f;
  225. +     char *data=_data;
  226. +     char *ptr;
  227.   
  228.       assert((data != NULL));
  229.       assert((size != 0));
  230. ***************
  231. *** 35,40 ****
  232. --- 37,43 ----
  233.           return 0;
  234.   #endif
  235.       assert((n <= (size_t)LONG_MAX));
  236. +     if( f&_IOBIN ) {
  237.       again:    
  238.       if((cnt = fp->_cnt) > 0)
  239.       {
  240. ***************
  241. *** 62,77 ****
  242.           }
  243.           else
  244.           { /* read in n bytes into data */
  245. !         if((cnt = _read(fp->_file, data, (unsigned long)n))<=0) {
  246.               fp->_flag |= ((cnt == 0) ? _IOEOF : _IOERR);
  247.               goto ret;
  248.           }
  249. !                 data+=cnt;
  250. !                 l+=cnt;
  251. !                 n-=cnt;
  252. !                 goto again;
  253.           }
  254.       }
  255.       ret:
  256.       return((l > 0) ? ((size_t)l / size) : 0);
  257.       }
  258. --- 65,133 ----
  259.           }
  260.           else
  261.           { /* read in n bytes into data */
  262. !         if((cnt = _read(fp->_file, data, (unsigned long)n)) != n)
  263. !         {   /* EOF or error */
  264. !             fp->_flag |= ((cnt >= 0) ? _IOEOF : _IOERR);
  265. !         }
  266. !         if( cnt>0 )
  267. !             l += cnt;
  268. !         }
  269. !     }
  270. !     } else {
  271. !     while( n>0 ) {
  272. !         if( (cnt=fp->_cnt)>0 ) {
  273. !         ptr=(char*)fp->_ptr;
  274. !         while( n>0 && cnt>0 ) {
  275. !             if( *ptr!='\r' ) {
  276. !             *data++=*ptr++;
  277. !             cnt--;
  278. !             n--;
  279. !             l++;
  280. !             } else {
  281. !             ptr++;
  282. !             cnt--;
  283. !             }
  284. !         }
  285. !         fp->_cnt=cnt;
  286. !         fp->_ptr=(unsigned char*)ptr;
  287. !         }
  288. !         if( n==0 ) break; /* done */
  289. !         /* wanna have n more bytes */
  290. !         if( n<fp->_bsiz ) {
  291. !         /* read in fp->_bsiz bytes into fp->_base and do it again */
  292. !         fp->_ptr = fp->_base;
  293. !         if((cnt = _read(fp->_file, fp->_base, (unsigned long)fp->_bsiz)) <= 0)
  294. !         {   /* EOF or error */
  295.               fp->_flag |= ((cnt == 0) ? _IOEOF : _IOERR);
  296.               goto ret;
  297.           }
  298. !         fp->_cnt = cnt;
  299. !         } else {
  300. !         /* read in n bytes into data */
  301. !         if((cnt = _read(fp->_file, data, (unsigned long)n)) != n)
  302. !         {   /* EOF or error */
  303. !             fp->_flag |= ((cnt >= 0) ? _IOEOF : _IOERR);
  304. !             /* if EOF but read bytes still convert CRLF */
  305. !             if( cnt<=0 ) goto ret;
  306. !         }
  307. !         ptr=data;
  308. !         while( cnt>0 ) {
  309. !             if( *ptr!='\r' ) {
  310. !             *data++=*ptr++;
  311. !             cnt--;
  312. !             n--;
  313. !             l++;
  314. !             } else {
  315. !             ptr++;
  316. !             cnt--;
  317. !             }
  318. !         }
  319. !         if( fp->_flag&_IOEOF )
  320. !             goto ret;
  321.           }
  322.       }
  323. +     }
  324. + 
  325.       ret:
  326.       return((l > 0) ? ((size_t)l / size) : 0);
  327.       }
  328. *** 1.10    1992/03/22 21:57:30
  329. --- fwrite.c    1992/03/24 18:54:27
  330. ***************
  331. *** 8,23 ****
  332.   #include <string.h>
  333.   #include "lib.h"
  334.   
  335. ! size_t  fwrite(data, size, count, fp)
  336. !     const register void *data;
  337. !     size_t size;
  338. !     size_t count;
  339. !     register FILE *fp;
  340. !     {
  341.       register size_t n, m;
  342.       register long l = 0;
  343.       long space;
  344.       unsigned int f = fp->_flag;
  345.   
  346.       if(f & _IORW)
  347.       {
  348. --- 8,28 ----
  349.   #include <string.h>
  350.   #include "lib.h"
  351.   
  352. ! size_t    fwrite(_data, size, count, fp)
  353. ! const void *_data;
  354. ! size_t size;
  355. ! size_t count;
  356. ! register FILE *fp;
  357. ! {
  358. !     const char *data=_data;
  359.       register size_t n, m;
  360.       register long l = 0;
  361.       long space;
  362.       unsigned int f = fp->_flag;
  363. +     const char *restart_buf;
  364. +     int have_nl;
  365. +     int wrote_cr;
  366. +     int line_flush;
  367.   
  368.       if(f & _IORW)
  369.       {
  370. ***************
  371. *** 34,69 ****
  372.       n =  count * size;
  373.       assert ( n <= (size_t)LONG_MAX);  /* otherwise impl will not work */
  374.   
  375. !     space = fp->_bsiz - fp->_cnt;
  376. !     while(n > 0)
  377. !     {
  378. !         m = (n > space)? space: n;
  379. !         bcopy(data, fp->_ptr, m);
  380. !         fp->_ptr += m;
  381. !         fp->_cnt += m;
  382. !         space -= m;
  383. !         if(space == 0)
  384. !         {
  385. !         if(fflush(fp))
  386.               return 0;
  387. !         space = fp->_bsiz;
  388. !         if(f & _IORW)
  389. !             fp->_flag |= _IOWRT; /* fflush resets this */
  390. !         }
  391. !         l += m;
  392. !         data = (char *)data + m;
  393. !         n -= m;
  394. !         if(n < space)
  395. !         continue;
  396. !         if((m = _write(fp->_file, data, (unsigned long)n))
  397. !            != (long)n)
  398. !         {
  399. !         fp->_flag |= _IOERR;
  400. !         return 0;
  401. !         }
  402. !         l += m;
  403. !         break;
  404.       }
  405. !     
  406.       return((l > 0) ? ((size_t)l / size) : 0);
  407. !     }
  408. --- 39,138 ----
  409.       n =  count * size;
  410.       assert ( n <= (size_t)LONG_MAX);  /* otherwise impl will not work */
  411.   
  412. !     if( f&_IOBIN ) {
  413. !       space = fp->_bsiz - fp->_cnt;
  414. !       while(n > 0)
  415. !       {
  416. !           m = (n > space)? space: n;
  417. !           bcopy(data, fp->_ptr, m);
  418. !           fp->_ptr += m;
  419. !           fp->_cnt += m;
  420. !           space -= m;
  421. !           if(space == 0)
  422. !           {
  423. !           if(fflush(fp))
  424. !               return 0;
  425. !           space = fp->_bsiz;
  426. !           if(f & _IORW)
  427. !               fp->_flag |= _IOWRT; /* fflush resets this */
  428. !           }
  429. !           l += m;
  430. !           data += m;
  431. !           n -= m;
  432. !           if(n < space)
  433. !           continue;
  434. !           if((m = _write(fp->_file, data, (unsigned long)n )) != (long)n)
  435. !           {
  436. !           fp->_flag |= _IOERR;
  437. !           return 0;
  438. !           }
  439. !           l += m;
  440. !           break;
  441. !       }
  442. !     } else {
  443. !       have_nl=1;
  444. !       wrote_cr=0;
  445. !       line_flush=0;
  446. !       /* this relies on having at least one byte buffer,
  447. !          otherwise we'll hang up when trying to write CRLF */
  448. !       while(n > 0)
  449. !       {
  450. !           space = fp->_bsiz - fp->_cnt;
  451. !           restart_buf=data;
  452. !           while( space>0 && n>0 ) {
  453. !         if( *data=='\n' ) {
  454. !           if( !wrote_cr ) {
  455. !             if( f&_IOLBF ) line_flush=1;
  456. !             *fp->_ptr++='\r';
  457. !             wrote_cr=1;
  458. !             have_nl=1;
  459. !           } else {
  460. !             *fp->_ptr++='\n';
  461. !             data++;
  462. !             wrote_cr=0;
  463. !             n--;
  464. !           }
  465. !         } else {
  466. !           *fp->_ptr++=*data++;
  467. !           n--;
  468. !         }
  469. !         space--;
  470. !         fp->_cnt++;
  471. !         l++;
  472. !           }
  473. ! 
  474. !           if( space==0 ) {
  475. !         if( have_nl ) {
  476. !           if(fflush(fp))
  477. !               return 0;
  478. !           if(f & _IORW)
  479. !               fp->_flag |= _IOWRT; /* fflush resets this */
  480. !           have_nl=0;
  481. !         } else {
  482. !         /* this will probably happen in nonbuffered mode only:
  483. !            try to write as much data in one go as possible */
  484. !           fp->_cnt=0;
  485. !           fp->_ptr=fp->_base;
  486. !           while( n && *data!='\n' ) {
  487. !             n--;
  488. !             data++;
  489. !           }
  490. !           if( (m=_write(fp->_file, restart_buf, data-restart_buf ))
  491. !               != data-restart_buf ) {
  492. !             fp->_flag |= _IOERR;
  493.               return 0;
  494. !           }
  495. !           l+=m;
  496. !         }
  497. !           }
  498. !       }
  499. !       if( line_flush ) {
  500. !          if(fflush(fp))
  501. !          return 0;
  502. !          if(f & _IORW)
  503. !          fp->_flag |= _IOWRT; /* fflush resets this */
  504. !       }
  505.       }
  506. ! 
  507.       return((l > 0) ? ((size_t)l / size) : 0);
  508. ! }
  509. *** 1.6    1991/07/23 22:06:28
  510. --- signal.c    1992/03/24 18:54:36
  511. ***************
  512. *** 15,21 ****
  513.   #include    <unistd.h>
  514.   
  515.   extern int __check_signals;        /* used in console i/o routines */
  516. ! #define    SIG_EXIT    10        /* exit code */
  517.   
  518.   struct sigarray_str {
  519.         __Sigfunc s_func;
  520. --- 15,21 ----
  521.   #include    <unistd.h>
  522.   
  523.   extern int __check_signals;        /* used in console i/o routines */
  524. ! #define SIG_EXIT    10        /* exit code */
  525.   
  526.   struct sigarray_str {
  527.         __Sigfunc s_func;
  528. ***************
  529. *** 40,49 ****
  530.       case SIGINT:
  531.       case SIGQUIT:
  532.           if (func != SIG_IGN)
  533. !             __check_signals += 1;
  534.           else
  535. !             __check_signals = (__check_signals == 1) ? 
  536. !                      0 : --__check_signals;
  537.       case SIGALRM:
  538.       case SIGABRT:
  539.           oldfunc = sig_array[sig].s_func;
  540. --- 40,49 ----
  541.       case SIGINT:
  542.       case SIGQUIT:
  543.           if (func != SIG_IGN)
  544. !             __check_signals |= (sig==SIGINT ? 1 : 2);
  545.           else
  546. !             __check_signals &= (sig==SIGINT ? ~1 : ~2);
  547. !         /* falltrough */
  548.       case SIGALRM:
  549.       case SIGABRT:
  550.           oldfunc = sig_array[sig].s_func;
  551.